def find_max_m(nums):
    """
    找出将倒排序整数数组分成m份（每份和相等）的最大m值
    
    参数:
        nums: 倒排序的整数数组
    
    返回:
        能够使数组分成等和分区的最大m值
    """
    total_sum = sum(nums)
    
    # 尝试从大到小的m值
    for m in range(len(nums), 0, -1):
        # 如果总和不能被m整除，跳过
        if total_sum % m != 0:
            continue
        
        target_sum = total_sum // m
        used = [False] * len(nums)
        
        # 尝试将数组分成m份，每份和为target_sum
        if can_partition(nums, used, 0, m, target_sum, 0):
            return m
    
    return 1  # 最小可能的m值为1

def can_partition(nums, used, start_index, remaining_partitions, target_sum, current_sum):
    """
    回溯检查是否能将数组分成指定份数，每份和相等
    
    参数:
        nums: 原始数组
        used: 标记元素是否已使用
        start_index: 当前考虑的起始索引
        remaining_partitions: 剩余需要填充的分区数
        target_sum: 每个分区的目标和
        current_sum: 当前分区已累积的和
    
    返回:
        是否能成功分区
    """
    # 成功分配所有分区
    if remaining_partitions == 0:
        return True
    
    # 当前分区已满足目标和，开始填充下一个分区
    if current_sum == target_sum:
        return can_partition(nums, used, 0, remaining_partitions - 1, target_sum, 0)
    
    # 尝试从start_index开始添加元素到当前分区
    for i in range(start_index, len(nums)):
        # 跳过已使用的元素或会导致当前分区和超出目标的元素
        if used[i] or current_sum + nums[i] > target_sum:
            continue
        
        # 避免重复尝试相同的值
        if i > start_index and nums[i] == nums[i-1] and not used[i-1]:
            continue
        
        used[i] = True
        if can_partition(nums, used, i + 1, remaining_partitions, target_sum, current_sum + nums[i]):
            return True
        used[i] = False
    
    return False

# 测试用例
if __name__ == "__main__":    
    # 测试用例
    test_cases = [
        [6, 4, 3, 3, 2],
        [10, 8, 6, 4, 2],
        [7, 7, 7],
        [5, 4, 3, 2, 1],
        [5, 4, 3, 2],
    ]
    
    for i, test in enumerate(test_cases):
        print(f"测试用例 {i+1} {test}: 最大的m值为 {find_max_m(test)}")